/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package cuatroenraya.jugadores;
import cuatroenraya.Jugador;

import java.util.ArrayList;


/**
 *
 * @author CortezNoemi
 */
public class JugadorAlumnoG8V2 extends Jugador {

    private ArbolDeEstados arbol=null;
    private NodoArbol m=null; 
    private Lista abierta = new Lista();
    private Lista cerrada= new Lista();
    private NodoArbol encontrado=null;
    private int[] jugada= new int [2];

    public int[] jugar(int[][] tablero)
    {

        if(usarJugadaPorDefecto(tablero))
        {
          return jugada;
        }
        else
        {
             //CREO EL ÁRBOL
                arbol=new ArbolDeEstados();
                arbol.setRaiz(this.armar(tablero));

             //EJECUTO EL ALGORITMO DE BUSQUEDA PRIMERO EL MEJOR
                this.encontrado=this.buscar();

                if(this.encontrado.isEsObjetivo())
                {
                   /**
                    * PUEDE SER UN OBJETIVO PARA MI O PARA MI OPONENTE
                    * Cuando es un estado del oponente debo hacer su jugada para evitar que ÉL haga la linea
                    */
                   jugada=encontrado.getJugada();

                }
                /**
                 * COMO NOSOTROS HACEMOS UN ARBOL DE DOS NIVELES PUEDE OCURRIR QUE NO HAYA ESTADOS OBJETIVOS
                 * EN EL ARBOL, SOBRE TODO AL PRINCIPIO, EN ESE CASO HAGO LA MEJOR JUGADA DISPONIBLE ENTRE
                 * TODOS LOS ESTADOS DE LOS DOS NIVELES
                */
                else
                {
                    NodoArbol hijoRaiz=arbol.getRaiz().mejorHijo();
                    NodoArbol hijoHijo=hijoRaiz.mejorHijo();

                    if(hijoRaiz.getHeuristica()<hijoHijo.getHeuristica())
                    {
                        jugada=hijoRaiz.getJugada();
                    }
                    else
                    {
                        if(hijoRaiz.getHeuristica()>hijoHijo.getHeuristica())
                            jugada=hijoHijo.getJugada();
                        else
                            jugada=hijoRaiz.getJugada();
                    }

                }
        }
        return jugada;
     
    }


    private boolean usarJugadaPorDefecto(int[][] tablero)
    {
        boolean usar=false;
        
        int cantfichas=0;

        // veo si el tablero esta vacio
        for(int i=0; i<8;i++)
        {
            for(int j=0;j<8;j++)
            {
                if(tablero[i][j]!=0)
                    cantfichas++;
            }
        }

        if(cantfichas==0)
        {
                jugada[0]=3;
                jugada[1]=4;
                usar=true;
        }

        return usar;
    }

     public NodoArbol buscar()
   {
        boolean llegoAlObjetivo= false;

      //INICIALIZO LAS VARIABLES NECESARIAS
        NodoArbol primero=arbol.getRaiz();
        this.abierta= new Lista();
        this.cerrada= new Lista();
        this.m=null;

      //Coloco el primer nodo del arbol en ABIERTA y en M
        this.abierta.insertarOrdenado(primero);

       NodoArbol aux= null;
       while (!this.abierta.estaVacia()&&!llegoAlObjetivo)
       {
           aux=(NodoArbol) this.abierta.getFrente().getInfo();

           // SI EL PRIMER NODO DE ABIERTA ES OBJETIVO FINALIZA LA BUSQUEDA Y DEVUELVO AUX
           if(aux.isEsObjetivo())
           {
                llegoAlObjetivo=true;
           }
           else
           {
            //SI EL NODO PERTENECE AL SEGUNDO NIVEL YA NO PUEDO EXPANDIRLO
            // ENTONCES NO HAGO NADA, DEJO QUE SE SIGA EXAMINANDO ABIERTA
                if(aux.getNivel()<2)
                    this.expandirNodo();
                else
                    this.abierta.borrar();
           }

       }

       return aux;
    }

    private void expandirNodo()
    {

     // Este método devuelve el primero que esta en ABIERTA y lo borra
        m=(NodoArbol) this.abierta.borrar();

     // Ahora busco los estados proximos al nodo M y los coloco en ABIERTA
        this.actualizarAbierta();
        this.cerrada.insertarUltimo(m);

    }

    private void actualizarAbierta()
    {

       if(m.getNivel()==1)
           this.abierta.insertarOrdenado(m.mejorHijo());
       else
       {
            ArrayList proximos= m.getSiguientes();

            for( int i=0; i< proximos.size(); i++)
            {
               NodoArbol aux=(NodoArbol) proximos.get(i);
               this.abierta.insertarOrdenado(aux);
            }
       }

    }


    private NodoArbol armar(int[][] tablero)
    {
            NodoArbol raiz= new NodoArbol();
      
            raiz.setTablero(tablero);
            raiz.setNivel(0);
            raiz.setEsObjetivo(false);
            raiz.setHeuristica(50000);

            raiz.setSiguientes(this.obtenerEstadosSiguientes(tablero,1));
        
            return raiz;
    }



    private ArrayList<NodoArbol> obtenerEstadosSiguientes(int[][] tablero, int nivel)
    {
        ArrayList<NodoArbol> siguientes= new ArrayList<NodoArbol> ();

        //RECORRO EL TABLERO Y GENERO UN ESTADO POR CASILLA VACIA
        for(int fila=0; fila< 8; fila++)
        {
                  for(int colum=0; colum< 8; colum++)
                 {

                    if(tablero[fila][colum]==0)
                    {
                       if(tendraVecinos(tablero, fila, colum, nivel))
                       {
                           NodoArbol nuevo=this.ProximoEstado(tablero, fila, colum, nivel);
                           siguientes.add(nuevo);
                       }
                    }
                 }
        }

        return siguientes;

    }

    private boolean tendraVecinos(int[][] estadoNivelAnterior, int f, int c, int ficha)
    {
        boolean vecinos=false;

        if(f==0)
        {
            switch(c)
            {
                case 0:
                {
                        if(estadoNivelAnterior[f][c+1]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f+1][c]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f+1][c+1]==ficha)
                            vecinos=true;
                        break;
                }
                case 7:
                {
                        if(estadoNivelAnterior[f][c-1]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f+1][c-1]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f+1][c]==ficha)
                            vecinos=true;
                        break;
                }

                default:
                {
                        if(estadoNivelAnterior[f][c-1]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f][c+1]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f+1][c]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f+1][c+1]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f+1][c-1]==ficha)
                            vecinos=true;
                        break;
                }

            }
        }

         if(f==7)
        {
            switch(c)
            {
                case 0:
                {
                        if(estadoNivelAnterior[f-1][c+1]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f-1][c]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f][c+1]==ficha)
                            vecinos=true;
                        break;
                }
                case 7:
                {
                        if(estadoNivelAnterior[f][c-1]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f-1][c-1]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f-1][c]==ficha)
                            vecinos=true;
                        break;
                }

                default:
                {
                        if(estadoNivelAnterior[f][c-1]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f][c+1]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f-1][c]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f-1][c+1]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f-1][c-1]==ficha)
                            vecinos=true;
                        break;
                }

            }
        }

        if(f!=0&&f!=7)
        {
            switch(c)
            {
                case 0:
                {        if(estadoNivelAnterior[f][c+1]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f-1][c+1]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f-1][c]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f+1][c]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f+1][c+1]==ficha)
                            vecinos=true;
                         break;
                }
                case 7:
                {
                        if(estadoNivelAnterior[f][c-1]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f-1][c-1]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f-1][c]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f+1][c]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f+1][c-1]==ficha)
                            vecinos=true;
                        break;
                }
                default:
                {
                        if(estadoNivelAnterior[f][c-1]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f][c+1]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f-1][c-1]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f-1][c]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f-1][c+1]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f+1][c]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f+1][c-1]==ficha)
                            vecinos=true;
                        if(estadoNivelAnterior[f+1][c+1]==ficha)
                            vecinos=true;
                        break;
                }

            }
        }
        return vecinos;
    }

    private NodoArbol ProximoEstado(int[][] tablero, int f, int c, int ficha)
    {
        int [][]estado= new int[8][8];

        //Primero: Copio el estado actual
         for(int fila=0; fila< 8; fila++)
        {
                  for(int colum=0; colum< 8; colum++)
                 {
                  estado[fila][colum]=tablero [fila][colum];
                 }
        }

        //Segundo:coloco la ficha en el lugar vacio encontrado
        estado[f][c]=ficha;

       // GUARDO EL ESTADO GENERADO EN EL NUEVO NODO DEL ARBOL
       
       NodoArbol nodo= new NodoArbol();
      
       nodo.setTablero(estado);
       nodo.setNivel(ficha);
       nodo.setHeuristica(this.calcularHeuristica(tablero,f,c,ficha));

       if(nodo.getHeuristica()==0)
           nodo.setEsObjetivo(true);
       else
           nodo.setEsObjetivo(false);

       int [] jug= new int [2];
       jug[0]=f;
       jug[1]=c;

       nodo.setJugada(jug);
       if(ficha==1)
           nodo.setTipo("Ofensiva");
       else
           nodo.setTipo("Defensiva");

       //Solo genero los siguientes para el primer nivel
       int nivelprox=ficha+1;

       if(!nodo.isEsObjetivo()&& nivelprox<3)
       {
       // Los estados siguientes seran las del oponente a partir del tablero original
           nodo.setSiguientes(this.obtenerEstadosSiguientes(tablero, nivelprox));
       }
        return nodo;
    }

    private int calcularHeuristica(int[][] estado, int filaJugada, int columJugada, int ficha) {

        int puntaje=4000;

        int puntajeHorizontal=0;
        int puntajeVertical=0;
        int puntajeOblicuo=0;
        
      //PUNTAJE SI SE FORMO UNA LINEA HORIZONTAL
        puntajeHorizontal=this.seFormaUnaLineaHorizontal(estado, filaJugada, columJugada, ficha);
//          
      // PUNTAJE SI SE FORMO UNA LINEA VERTICAL
        puntajeVertical=this.seFormaUnaLineaVertical(estado, filaJugada, columJugada, ficha);
//         
      //PUNTAJE SI SE FORMO UNA FILA OBLICUA
        puntajeOblicuo=this.seFormaUnaDiagonal(estado, filaJugada, columJugada, ficha);

        if(ficha==1)
        {   // VERIFICO SI SE FORMA ALGUNA LINEA QUE PARA EL JUGADOR ALUMNO VALE 4000
            if(puntajeHorizontal==4000||puntajeOblicuo==4000||puntajeVertical==4000)
               puntaje=0;
            else
            {
                //SI ENTRA ES POR QUE NO SE FORMO NINGUNA LINEA
                if(puntajeHorizontal>puntajeVertical)
                {
                    if(puntajeHorizontal>puntajeOblicuo)
                        puntaje=puntaje-puntajeHorizontal;
                    else
                        puntaje=puntaje-puntajeOblicuo;

                }
                else
                {
                    if(puntajeVertical>puntajeOblicuo)
                        puntaje=puntaje-puntajeVertical;
                    else
                        puntaje=puntaje-puntajeOblicuo;
                }
            }
        }
        else
        {
            // VERIFICO SI SE FORMA ALGUNA LINEA QUE PARA EL OPONENTE VALE 3900
            if(puntajeHorizontal==3900||puntajeOblicuo==3900||puntajeVertical==3900)
                puntaje=0;
            else
            {
                //SI ENTRA ES POR QUE NO SE FORMO NINGUNA LINEA
                if(puntajeHorizontal>puntajeVertical)
                {
                    if(puntajeHorizontal>puntajeOblicuo)
                        puntaje=puntaje-puntajeHorizontal;
                    else
                        puntaje=puntaje-puntajeOblicuo;

                }
                else
                {
                    if(puntajeVertical>puntajeOblicuo)
                        puntaje=puntaje-puntajeVertical;
                    else
                        puntaje=puntaje-puntajeOblicuo;
                }
            }

        }
        return puntaje;
    }


 private int seFormaUnaLineaHorizontal(int[][] estado,int filaJugada, int columJugada, int ficha) {

       int puntaje=0;

       int premioLinea=4000;
       int premioSeguidilla=1000;

       if(ficha==2)
       {
           premioSeguidilla=975;
           premioLinea=3900;
       }

       switch (columJugada)
       {
           case 0:
           {
               if(this.filaHorizontalComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                 puntaje=premioLinea;
               else
               {
                 puntaje=premioSeguidilla*this.seguidillaHorizontalDeFichas(estado, filaJugada, columJugada, ficha);
               }
               break;
           }

           case 1:
           {
               if(this.filaHorizontalComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                  puntaje=premioLinea;
               else
               {
                   if(this.filaHorizontalComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                       puntaje=premioLinea;
                   else
                       puntaje=premioSeguidilla*this.seguidillaHorizontalDeFichas(estado, filaJugada, columJugada, ficha);
               }
               break;
           }
           case 2:
          {
               if(this.filaHorizontalComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                  puntaje=premioLinea;
               else
               {
                   if(this.filaHorizontalComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                       puntaje=premioLinea;
                   else
                   {
                       if(this.filaHorizontalComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                       puntaje=premioLinea;
                       else
                          puntaje=premioSeguidilla*this.seguidillaHorizontalDeFichas(estado, filaJugada, columJugada, ficha);
                   }
               }
               break;
          }
           case 3:
          {
               if(this.filaHorizontalComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                  puntaje=premioLinea;
               else
               {
                   if(this.filaHorizontalComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                       puntaje=premioLinea;
                   else
                   {
                       if(this.filaHorizontalComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                       puntaje=premioLinea;
                       else
                       {
                            if(this.filaHorizontalComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                            puntaje=premioLinea;
                            else
                            {
                                puntaje=premioSeguidilla*this.seguidillaHorizontalDeFichas(estado, filaJugada, columJugada, ficha);
                            }
                       }
                   }
               }
               break;
          }

           case 4:
          {
               if(this.filaHorizontalComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                  puntaje=premioLinea;
               else
               {
                   if(this.filaHorizontalComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                       puntaje=premioLinea;
                   else
                   {
                       if(this.filaHorizontalComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                       puntaje=premioLinea;
                       else
                       {
                            if(this.filaHorizontalComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                            puntaje=premioLinea;
                            else
                            {
                                puntaje=premioSeguidilla*this.seguidillaHorizontalDeFichas(estado, filaJugada, columJugada, ficha);
                            }
                       }
                   }
               }
               break;
          }
           case 5:
          {
               if(this.filaHorizontalComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                  puntaje=puntaje+premioLinea;
               else
               {
                   if(this.filaHorizontalComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                       puntaje=premioLinea;
                   else
                   {
                       if(this.filaHorizontalComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                       puntaje=premioLinea;
                       else
                                puntaje=premioSeguidilla*this.seguidillaHorizontalDeFichas(estado, filaJugada, columJugada, ficha);
                   }
               }
               break;
          }
           case 6:
          {
               if(this.filaHorizontalComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                  puntaje=premioLinea;
               else
               {
                   if(this.filaHorizontalComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                       puntaje=premioLinea;
                   else
                       puntaje=premioSeguidilla*this.seguidillaHorizontalDeFichas(estado, filaJugada, columJugada, ficha);
               }
               break;
          }
           case 7:
           {
               if(this.filaHorizontalComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                   puntaje=premioLinea;
               else
                   puntaje=premioSeguidilla*this.seguidillaHorizontalDeFichas(estado, filaJugada, columJugada, ficha);
               break;
           }
       }

       if(ficha==1)
       {
           if(puntaje==-2000)
               puntaje=2000;
       }
       else
       {
           if(puntaje==-1950)
               puntaje=2500;
       }
       return puntaje;
    }

 private int seFormaUnaLineaVertical(int[][] estado,int filaJugada, int columJugada, int ficha) {

       int puntaje=0;
       int premioLinea=4000;
       int premioSeguidilla=1000;

       if(ficha==2)
       {
           premioSeguidilla=975;
           premioLinea=3900;
       }
       
       switch (filaJugada)
       {
           case 0:
           {
               if(this.filaVerticalComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                   puntaje=premioLinea;
               else
               {
                 puntaje=premioSeguidilla*this.seguidillaVerticalDeFichas(estado, filaJugada, columJugada,ficha);
               }
               break;
           }

           case 1:
           {
               if(this.filaVerticalComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                  puntaje=premioLinea;
               else
               {
                   if(this.filaVerticalComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                       puntaje=premioLinea;
                   else
                       puntaje=premioSeguidilla*this.seguidillaVerticalDeFichas(estado, filaJugada,columJugada, ficha);
               }
               break;
           }
           case 2:
          {
               if(this.filaVerticalComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                  puntaje=premioLinea;
               else
               {
                   if(this.filaVerticalComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                       puntaje=premioLinea;
                   else
                   {
                       if(this.filaVerticalComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                       puntaje=premioLinea;
                       else
                          puntaje=premioSeguidilla*this.seguidillaVerticalDeFichas(estado, filaJugada,columJugada, ficha);
                   }
               }
               break;
          }
           case 3:
          {
               if(this.filaVerticalComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                  puntaje=premioLinea;
               else
               {
                   if(this.filaVerticalComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                       puntaje=premioLinea;
                   else
                   {
                       if(this.filaVerticalComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                       puntaje=premioLinea;
                       else
                       {
                            if(this.filaVerticalComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                            puntaje=premioLinea;
                            else
                            {
                                puntaje=premioSeguidilla*this.seguidillaVerticalDeFichas(estado,filaJugada, columJugada, ficha);
                            }
                       }
                   }
               }
               break;
          }

           case 4:
          {
               if(this.filaVerticalComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                  puntaje=premioLinea;
               else
               {
                   if(this.filaVerticalComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                       puntaje=premioLinea;
                   else
                   {
                       if(this.filaVerticalComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                       puntaje=premioLinea;
                       else
                       {
                            if(this.filaVerticalComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                            puntaje=premioLinea;
                            else
                            {
                                puntaje=premioSeguidilla*this.seguidillaVerticalDeFichas(estado,filaJugada, columJugada, ficha);
                            }
                       }
                   }
               }
               break;
          }
           case 5:
          {
               if(this.filaVerticalComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                  puntaje=premioLinea;
               else
               {
                   if(this.filaVerticalComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                       puntaje=premioLinea;
                   else
                   {
                       if(this.filaVerticalComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                       puntaje=premioLinea;
                       else
                                puntaje=premioSeguidilla*this.seguidillaVerticalDeFichas(estado,filaJugada, columJugada, ficha);
                   }
               }
               break;
          }
           case 6:
          {
               if(this.filaVerticalComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                  puntaje=premioLinea;
               else
               {
                   if(this.filaVerticalComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                       puntaje=premioLinea;
                   else
                       puntaje=puntaje+premioSeguidilla*this.seguidillaVerticalDeFichas(estado, filaJugada,columJugada, ficha);
               }
               break;
          }
           case 7:
           {
               if(this.filaVerticalComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                   puntaje=premioLinea;
               else
                   puntaje=premioSeguidilla*this.seguidillaVerticalDeFichas(estado, filaJugada,columJugada, ficha);
               break;
           }
       }

       if(ficha==1)
       {
           if(puntaje==-2000)
               puntaje=2000;
       }
       else
       {
           if(puntaje==-1950)
               puntaje=2500;
       }
       
       return puntaje;
    }

 private int seFormaUnaDiagonal(int[][] estado,int filaJugada, int columJugada, int ficha)
 {
       int puntaje=0;

       int premioSeguidilla=1000;
       int penalizacion=0;

       if(ficha==2)
       {
           penalizacion=-100;
           premioSeguidilla=900;
           
       }

       
        switch (filaJugada)
       {
           case 0:
           {
              puntaje=this.filaOblicuaFilaCERO(estado, filaJugada, columJugada, ficha);
              if(puntaje==4000)
                  puntaje=puntaje+penalizacion;
              break;
           }

           case 1:
           {
              puntaje=this.filaOblicuaFilaUNO(estado, filaJugada, columJugada, ficha);
              if(puntaje==4000)
                  puntaje=puntaje+penalizacion;
              break;
           }

           case 2:
           {
               puntaje=this.filaOblicuaFilaDOS(estado, filaJugada, columJugada, ficha);
               if(puntaje==4000)
                  puntaje=puntaje+penalizacion;
               break;
           }
            case 3:
            {
                puntaje=this.filaOblicuaFilaTRES(estado, filaJugada, columJugada, ficha);
                if(puntaje==4000)
                  puntaje=puntaje+penalizacion;
                break;
            }

            case 4:
            {
                puntaje=this.filaOblicuaFilaCUATRO(estado, filaJugada, columJugada, ficha);
                if(puntaje==4000)
                  puntaje=puntaje+penalizacion;
                break;
            }

            case 5:
            {
                puntaje=this.filaOblicuaFilaCINCO(estado, filaJugada, columJugada, ficha);
                if(puntaje==4000)
                  puntaje=puntaje+penalizacion;
                break;
            }
            case 6:
            {
                puntaje=this.filaOblicuaFilaSEIS(estado, filaJugada, columJugada, ficha);
                if(puntaje==4000)
                  puntaje=puntaje+penalizacion;
                break;
            }

            case 7:
            {
                puntaje=this.filaOblicuaFilaSIETE(estado, filaJugada, columJugada, ficha);
                if(puntaje==4000)
                  puntaje=puntaje+penalizacion;
                break;
            }

        }
        //SI NO SE FORMO NINGUNA LINEA EL PUNTAJE ES 0,ENTONCES VERIFICO SI SE FORMO ALGUNA SEGUIDILLA DE FICHAS
        if(puntaje==0)
        {
            puntaje=premioSeguidilla*this.seguidillaOblicuaDeFichas(estado, filaJugada, columJugada, ficha);
        }
         return puntaje;

    }

private int filaOblicuaFilaCERO(int[][] estado,int filaJugada, int columJugada, int ficha)
{
    int puntaje=0;
    int premio=4000;

    switch(columJugada)
               {
                   case 0:
                   {
                        if(this.filaOblicuaDecrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                            puntaje=premio;
                       break;
                   }
                   case 1:
                   {
                       if(this.filaOblicuaDecrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=premio;
                       break;
                   }
                   case 2:
                   {
                       if(this.filaOblicuaDecrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=premio;
                       break;
                   }
                   case 3:
                   {
                       if(this.filaOblicuaDecrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=premio;
                       if(this.filaOblicuaCrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=premio;
                       break;
                   }
                   case 4:
                   {
                       if(this.filaOblicuaDecrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=premio;
                       if(this.filaOblicuaCrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=premio;
                       break;
                   }
                   // para 5 6 y 7 es igual
                   default:
                   {
                       if(this.filaOblicuaCrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=premio;
                       break;
                   }
               }

    return puntaje;
}

private int filaOblicuaFilaUNO(int[][] estado,int filaJugada, int columJugada, int ficha)
{
    int puntaje=0;
    int premio=4000;

    switch(columJugada)
               {
                   case 0:
                   {
                       if(this.filaOblicuaDecrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 1:
                   {
                       if(this.filaOblicuaDecrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 2:
                   {
                       if(this.filaOblicuaDecrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 3:
                   {
                       if(this.filaOblicuaDecrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 4:
                   {
                       if(this.filaOblicuaDecrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 5:
                   {
                       if(this.filaOblicuaDecrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 6:
                   {
                       if(this.filaOblicuaCrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }

                   case 7:
                   {
                       if(this.filaOblicuaCrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
               }

    return puntaje;
}

private int filaOblicuaFilaDOS(int[][] estado,int filaJugada, int columJugada, int ficha)
{
    int puntaje=0;
    int premio=4000;

    switch(columJugada)
               {
                   case 0:
                   {
                       if(this.filaOblicuaDecrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 1:
                   {
                       if(this.filaOblicuaDecrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 2:
                   {
                       if(this.filaOblicuaDecrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 3:
                   {
                       if(this.filaOblicuaDecrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 4:
                   {
                       if(this.filaOblicuaDecrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 5:
                   {
                       if(this.filaOblicuaDecrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 6:
                   {
                       if(this.filaOblicuaDecrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }

                   case 7:
                   {
                       if(this.filaOblicuaCrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
               }

    return puntaje;
}

private int filaOblicuaFilaTRES(int[][] estado,int filaJugada, int columJugada, int ficha)
{
    int puntaje=0;
    int premio=4000;

  

    switch(columJugada)
               {
                   case 0:
                   {
                       if(this.filaOblicuaDecrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=premio;
                       if(this.filaOblicuaCrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=premio;
                       break;
                   }
                   case 1:
                   {
                       if(this.filaOblicuaDecrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=premio;
                       if(this.filaOblicuaDecrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=premio;
                       if(this.filaOblicuaCrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=premio;
                       if(this.filaOblicuaCrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=premio;
                       break;
                   }
                   case 2:
                   {
                       if(this.filaOblicuaDecrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=premio;
                       if(this.filaOblicuaDecrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=premio;
                       if(this.filaOblicuaDecrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=premio;
                       if(this.filaOblicuaCrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 3:
                   {
                       if(this.filaOblicuaDecrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 4:
                   {
                       if(this.filaOblicuaDecrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 5:
                   {
                       if(this.filaOblicuaDecrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 6:
                   {
                       if(this.filaOblicuaDecrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }

                   case 7:
                   {
                       if(this.filaOblicuaDecrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
               }

    return puntaje;
}

private int filaOblicuaFilaCUATRO(int[][] estado,int filaJugada, int columJugada, int ficha)
{
    int puntaje=0;
    int premio=4000;

    switch(columJugada)
               {
                   case 0:
                   {
                       if(this.filaOblicuaDecrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 1:
                   {
                       if(this.filaOblicuaDecrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 2:
                   {
                       if(this.filaOblicuaDecrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 3:
                   {
                       if(this.filaOblicuaDecrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 4:
                   {
                       if(this.filaOblicuaDecrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 5:
                   {
                       if(this.filaOblicuaDecrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 6:
                   {
                       if(this.filaOblicuaDecrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }

                   case 7:
                   {
                       if(this.filaOblicuaDecrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoPrimeraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
               }

    return puntaje;
}

private int filaOblicuaFilaCINCO(int[][] estado,int filaJugada, int columJugada, int ficha)
{
    int puntaje=0;
    int premio=4000;

    switch(columJugada)
               {
                   case 0:
                   {
                       if(this.filaOblicuaCrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 1:
                   {
                       if(this.filaOblicuaDecrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 2:
                   {
                       if(this.filaOblicuaDecrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 3:
                   {
                       if(this.filaOblicuaDecrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 4:
                   {
                       if(this.filaOblicuaDecrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 5:
                   {
                       if(this.filaOblicuaDecrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 6:
                   {
                       if(this.filaOblicuaDecrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoSegundaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }

                   case 7:
                   {
                       if(this.filaOblicuaDecrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
               }

    return puntaje;
}
private int filaOblicuaFilaSEIS(int[][] estado,int filaJugada, int columJugada, int ficha)
{
    int puntaje=0;
    int premio=4000;

    switch(columJugada)
               {
                   case 0:
                   {
                       if(this.filaOblicuaCrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 1:
                   {
                       if(this.filaOblicuaCrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 2:
                   {
                       if(this.filaOblicuaDecrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 3:
                   {
                       if(this.filaOblicuaDecrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 4:
                   {
                       if(this.filaOblicuaDecrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 5:
                   {
                       if(this.filaOblicuaDecrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 6:
                   {
                       if(this.filaOblicuaDecrecienteComoTerceraFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaDecrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }

                   case 7:
                   {
                       if(this.filaOblicuaDecrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
               }

    return puntaje;
}

private int filaOblicuaFilaSIETE(int[][] estado,int filaJugada, int columJugada, int ficha)
{
    int puntaje=0;
    int premio=4000;

    switch(columJugada)
               {
                   case 0:
                   {
                       if(this.filaOblicuaCrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 1:
                   {
                       if(this.filaOblicuaCrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 2:
                   {
                       if(this.filaOblicuaCrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 3:
                   {
                       if(this.filaOblicuaDecrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   case 4:
                   {
                       if(this.filaOblicuaDecrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       if(this.filaOblicuaCrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }
                   //para 5-6-7 es igual
                   default:
                   {
                       if(this.filaOblicuaDecrecienteComoCuartaFicha(estado, filaJugada, columJugada, ficha))
                           puntaje=puntaje+premio;
                       break;
                   }

               }

    return puntaje;
}


private boolean filaOblicuaDecrecienteComoPrimeraFicha(int[][] estado,int filaJugada, int columJugada, int ficha)
{
    boolean resultado=false;

    if(estado[filaJugada+1][columJugada+1]==ficha&& estado[filaJugada+2][columJugada+2]== ficha&& estado[filaJugada+3][columJugada+3]==ficha)
        resultado=true;

    return resultado;
}

private boolean filaOblicuaCrecienteComoPrimeraFicha(int[][] estado,int filaJugada, int columJugada, int ficha)
{
    boolean resultado=false;

    if(estado[filaJugada+1][columJugada-1]==ficha&& estado[filaJugada+2][columJugada-2]== ficha&& estado[filaJugada+3][columJugada-3]==ficha)
        resultado=true;

    return resultado;
}

private boolean filaOblicuaDecrecienteComoSegundaFicha(int[][] estado,int filaJugada, int columJugada, int ficha)
{
    boolean resultado=false;

    if(estado[filaJugada-1][columJugada-1]==ficha&& estado[filaJugada+1][columJugada+1]== ficha&& estado[filaJugada+2][columJugada+2]==ficha)
        resultado=true;

    return resultado;
}

private boolean filaOblicuaCrecienteComoSegundaFicha(int[][] estado,int filaJugada, int columJugada, int ficha)
{
    boolean resultado=false;

    if(estado[filaJugada-1][columJugada+1]==ficha&& estado[filaJugada+1][columJugada-1]== ficha&& estado[filaJugada+2][columJugada-2]==ficha)
        resultado=true;

    return resultado;
}


private boolean filaOblicuaDecrecienteComoTerceraFicha(int[][] estado,int filaJugada, int columJugada, int ficha)
{
    boolean resultado=false;

    if(estado[filaJugada-1][columJugada-1]==ficha&& estado[filaJugada-2][columJugada-2]== ficha&& estado[filaJugada+1][columJugada+1]==ficha)
        resultado=true;

    return resultado;
}

private boolean filaOblicuaCrecienteComoTerceraFicha(int[][] estado,int filaJugada, int columJugada, int ficha)
{
    boolean resultado=false;

    if(estado[filaJugada+1][columJugada-1]==ficha&& estado[filaJugada-1][columJugada+1]== ficha&& estado[filaJugada-2][columJugada+2]==ficha)
        resultado=true;

    return resultado;
}

private boolean filaOblicuaDecrecienteComoCuartaFicha(int[][] estado,int filaJugada, int columJugada, int ficha)
{
    boolean resultado=false;

    if(estado[filaJugada-1][columJugada-1]==ficha&& estado[filaJugada-2][columJugada-2]== ficha&& estado[filaJugada-3][columJugada-3]==ficha)
        resultado=true;

    return resultado;
}

private boolean filaOblicuaCrecienteComoCuartaFicha(int[][] estado,int filaJugada, int columJugada, int ficha)
{
    boolean resultado=false;

    if(estado[filaJugada-1][columJugada+1]==ficha&& estado[filaJugada-2][columJugada+2]== ficha&& estado[filaJugada-3][columJugada+3]==ficha)
        resultado=true;

    return resultado;
}

private boolean filaHorizontalComoPrimeraFicha(int[][] estado,int filaJugada, int columJugada, int ficha)
{
    boolean resultado=false;

    if(estado[filaJugada][columJugada+1]==ficha&& estado[filaJugada][columJugada+2]== ficha&& estado[filaJugada][columJugada+3]==ficha)
        resultado=true;

    return resultado;
}

private boolean filaVerticalComoPrimeraFicha(int[][] estado,int filaJugada, int columJugada, int ficha)
{
    boolean resultado=false;

    if(estado[filaJugada+1][columJugada]==ficha&& estado[filaJugada+2][columJugada]== ficha&& estado[filaJugada+3][columJugada]==ficha)
        resultado=true;

    return resultado;
}

private boolean filaHorizontalComoSegundaFicha(int[][] estado,int filaJugada, int columJugada, int ficha)
{
    boolean resultado=false;

    if(estado[filaJugada][columJugada-1]==ficha&& estado[filaJugada][columJugada+1]== ficha&& estado[filaJugada][columJugada+2]==ficha)
        resultado=true;

    return resultado;
}

private boolean filaVerticalComoSegundaFicha(int[][] estado,int filaJugada, int columJugada, int ficha)
{
    boolean resultado=false;

    if(estado[filaJugada-1][columJugada]==ficha&& estado[filaJugada+1][columJugada]== ficha&& estado[filaJugada+2][columJugada]==ficha)
        resultado=true;

    return resultado;
}


private boolean filaHorizontalComoTerceraFicha(int[][] estado,int filaJugada, int columJugada, int ficha)
{
    boolean resultado=false;

    if(estado[filaJugada][columJugada-1]==ficha&& estado[filaJugada][columJugada-2]== ficha&& estado[filaJugada][columJugada+1]==ficha)
        resultado=true;

    return resultado;
}

private boolean filaVerticalComoTerceraFicha(int[][] estado,int filaJugada, int columJugada, int ficha)
{
    boolean resultado=false;

    if(estado[filaJugada+1][columJugada]==ficha&& estado[filaJugada-1][columJugada]== ficha&& estado[filaJugada-2][columJugada]==ficha)
        resultado=true;

    return resultado;
}

private boolean filaHorizontalComoCuartaFicha(int[][] estado,int filaJugada, int columJugada, int ficha)
{
    boolean resultado=false;

    if(estado[filaJugada][columJugada-1]==ficha&& estado[filaJugada][columJugada-2]== ficha&& estado[filaJugada][columJugada-3]==ficha)
        resultado=true;

    return resultado;
}

private boolean filaVerticalComoCuartaFicha(int[][] estado,int filaJugada, int columJugada, int ficha)
{
    boolean resultado=false;

    if(estado[filaJugada-1][columJugada]==ficha&& estado[filaJugada-2][columJugada]== ficha&& estado[filaJugada-3][columJugada]==ficha)
        resultado=true;

    return resultado;
}

private int seguidillaHorizontalDeFichas(int[][] estado,int filaJugada, int columJugada, int ficha)
{

    int unaAntes=columJugada-1;
    int dosAntes=columJugada-2;

    int unaDespues=columJugada+1;
    int dosDespues=columJugada+2;

    int cantHaciaAdelante=0;
    int cantidadHaciaAtras=0;
    int cantTotal=0;

    boolean posicAntVacia=false;
    boolean posicPostVacia=false;
    boolean posicDosAntVacia=false;
    boolean posicDosPostVacia=false;

    if(unaAntes>=0)
    {
        if(estado[filaJugada][unaAntes]==ficha)
        {    cantidadHaciaAtras++;

            if(dosAntes>=0)
            {
                if(estado[filaJugada][dosAntes]==ficha)
                {
                    cantidadHaciaAtras++;
                }
                else
                {
                     if(estado[filaJugada][dosAntes]==0)
                         posicDosAntVacia=true;
                }

            }

        }
        else
        {
             if(estado[filaJugada][unaAntes]==0)
                 posicAntVacia=true;
        }
    }

    if(unaDespues<=7)
    {
         if(estado[filaJugada][unaDespues]==ficha)  
         {
                cantHaciaAdelante++;
                 if(dosDespues<=7)
                {
                     if(estado[filaJugada][dosDespues]==ficha)
                        cantHaciaAdelante++;
                    else
                    {
                         if(estado[filaJugada][dosDespues]==0)
                             posicDosPostVacia=true;
                    }
                }
         }
         else
        {
             if(estado[filaJugada][unaDespues]==0)
                 posicPostVacia=true;
        }
    }

    cantTotal=cantHaciaAdelante+cantidadHaciaAtras;// nunca sera mayor a dos por que si no formarian cuatro

    if(cantTotal==2)
    {
        //podre luego formar cuatro???
        if(cantHaciaAdelante==2)
        {
            int tresDespues=dosDespues+1;

                if(tresDespues <8)
                {
                    if(estado[filaJugada][tresDespues]==0&&posicAntVacia)
                          cantTotal=-2;// Le doy un valor especial para identificar la doble posibilidad de formar linea de cuatro
                    if(estado[filaJugada][tresDespues]!=0&&!posicAntVacia)
                          cantTotal=0;// lo descarto por no tener posibilidades

                }
                else
                {
                    if(!posicDosAntVacia)
                    cantTotal=0;// lo descarto por no tener posibilidades
                }

        }
        else
        {
            if(cantidadHaciaAtras==2)
            {
                int tresAntes=dosAntes-1;

                if(tresAntes >=0)
                {
                    if(estado[filaJugada][tresAntes]==0&&posicPostVacia)
                          cantTotal=-2; // Le doy un valor especial para identificar la doble posibilidad de formar linea de cuatro
                    else
                    {
                        if(estado[filaJugada][tresAntes]!=0&&!posicPostVacia)
                          cantTotal=0;// lo descarto por no tener posibilidades
                    }
                }
                else
                {
                    if(!posicDosPostVacia)
                    cantTotal=0;// lo descarto por no tener posibilidades
                }
            }
            else
            {
                // si entro es por que alineo tres con una antes y una despues

                if(posicDosAntVacia||posicDosPostVacia);// sera false solo cuando ambas posic estan ocupadas
                else
                {
                    cantTotal=0;// lo descarto por no tener posibilidades
                }
            }
        }
    }

    return cantTotal;
}

private int seguidillaVerticalDeFichas(int[][] estado,int filaJugada, int columJugada, int ficha)
{
    
    int unaAntes=filaJugada-1;
    int dosAntes=filaJugada-2;

    int unaDespues=filaJugada+1;
    int dosDespues=filaJugada+2;

    int cantHaciaAdelante=0;
    int cantidadHaciaAtras=0;
    int cantTotal=0;

    boolean posicAntVacia=false;
    boolean posicPostVacia=false;
    boolean posicDosAntVacia=false;
    boolean posicDosPostVacia=false;


    if(unaAntes>=0)
    {
        if(estado[unaAntes][columJugada]==ficha)      
        {
            cantidadHaciaAtras++;
            if(dosAntes>=0)
            {
                if(estado[dosAntes][columJugada]==ficha)
                    cantidadHaciaAtras++;
                else
                {
                     if(estado[dosAntes][columJugada]==0)
                         posicDosAntVacia=true;
                }
            }
        }
        else
        {
             if(estado[unaAntes][columJugada]==0)
                 posicAntVacia=true;
        }
    }
    if(unaDespues<=7)
    {
         if(estado[unaDespues][columJugada]==ficha)
         {
                cantHaciaAdelante++;
         
                if(dosDespues<=7)
                {
                     if(estado[dosDespues][columJugada]==ficha)
                        cantHaciaAdelante++;
                     else
                    {
                         if(estado[dosDespues][columJugada]==0)
                             posicDosPostVacia=true;
                    }
                }
         }
         else
        {
             if(estado[unaDespues][columJugada]==0)
                 posicPostVacia=true;
        }
    }

    cantTotal=cantHaciaAdelante+cantidadHaciaAtras;// nunca sera mayor a dos por que si no formarian cuatro

   if(cantTotal==2)
    {
        //podre luego formar cuatro???
        if(cantHaciaAdelante==2)
        {
            int tresDespues=dosDespues+1;

                if(tresDespues <8)
                {
                    if(estado[tresDespues][columJugada]==0&&posicAntVacia);
                          cantTotal=-2;// Le doy un valor especial para identificar la doble posibilidad de formar linea de cuatro
                    if(estado[tresDespues][columJugada]!=0&&!posicAntVacia);
                          cantTotal=0;// lo descarto por no tener posibilidades

                }
                else
                {
                    if(!posicDosAntVacia)
                    cantTotal=0;
                }

        }
        else
        {
            if(cantidadHaciaAtras==2)
            {
                int tresAntes=dosAntes-1;

                if(tresAntes>=0)
                {
                    if(estado[tresAntes][columJugada]==0&&posicPostVacia);
                          cantTotal=-2;// Le doy un valor especial para identificar la doble posibilidad de formar linea de cuatro
                    if(estado[tresAntes][columJugada]!=0&&!posicPostVacia);
                          cantTotal=0;// lo descarto por no tener posibilidades

                }
                else
                {
                    if(!posicDosPostVacia)
                    cantTotal=0;
                }
            }
            else
            {
                // si entro es por que alineo tres con una antes y una despues

                if(posicDosAntVacia||posicDosPostVacia);
                else
                {
                    cantTotal=0;// lo descarto por no tener posibilidades
                }
            }
        }
    }

        
    return cantTotal;
}

private int seguidillaOblicuaDeFichas(int[][] estado,int filaJugada, int columJugada, int ficha)
{

    int unaFilaAntes=filaJugada-1;
    int dosFilasAntes=filaJugada-2;

    int unaFilaDespues=filaJugada+1;
    int dosFilasDespues=filaJugada+2;

    int unaColumnaAntes=columJugada-1;
    int dosColumnaAntes=columJugada-2;

    int unaColumnaDespues=columJugada+1;
    int dosColumnaDespues=columJugada+2;

    int cant=0;//ficha de la jugada

    if(unaFilaAntes>=0)
    {
         if(unaColumnaAntes>=0)
        {
            if(estado[unaFilaAntes][unaColumnaAntes]==ficha)
            {
                cant++;
                
                if(dosFilasAntes>=0)
                {
                    if(dosColumnaAntes>=0)
                   {
                       if(estado[dosFilasAntes][dosColumnaAntes]==ficha)
                           cant++;
                   }

                }

            }

                
        }
         if(unaColumnaDespues<=7)
        {
            if(estado[unaFilaAntes][unaColumnaDespues]==ficha)
            {
                cant++;
                
                if(dosFilasAntes>=0)
                {
                    if(dosColumnaDespues<=7)
                   {
                       if(estado[dosFilasAntes][dosColumnaDespues]==ficha)
                           cant++;
                   }
                }

            }


        }
    

    }

    if(unaFilaDespues<=7)
    {
         if(unaColumnaAntes>=0)
        {
            if(estado[unaFilaDespues][unaColumnaAntes]==ficha)
            {
                cant++;

                if(dosFilasDespues<=7)
                {
                    if(dosColumnaAntes>=0)
                   {
                       if(estado[dosFilasDespues][dosColumnaAntes]==ficha)
                           cant++;
                   }

                }

            }


        }
         if(unaColumnaDespues<=7)
        {
            if(estado[unaFilaDespues][unaColumnaDespues]==ficha)
            {
                cant++;

                if(dosFilasDespues<=7)
                {
                    if(dosColumnaDespues<=7)
                   {
                       if(estado[dosFilasDespues][dosColumnaDespues]==ficha)
                           cant++;
                   }
                }

            }


        }


    }


    return cant;
}

    public String devolverIntegrantes ()
    {
        return "Casas Ruggieri Jésica - Cortez Noemí Andrea - Paez Gonzalo Martín";
    }

        public String devolverCurso ()
    {
        return "Curso 5K4";
    }

     public String devolverGrupo ()
    {
        return "Grupo Nº : Casas Ruggieri Jésica - Cortez Noemí Andrea - Paez Gonzalo Martín";
    }



//OTRAS CLASES
public class ArbolDeEstados {
    private NodoArbol raiz;

    public NodoArbol getRaiz() {
        return raiz;
    }

    public void setRaiz(NodoArbol raiz) {
        this.raiz = raiz;
    }

}


public class NodoArbol implements Comparable{

    private int[][] tablero;
    private int heuristica;
    private int nivel;
    private boolean esObjetivo;
    private int [] jugada= new int [2];
    private String tipo;

    private ArrayList<NodoArbol> siguientes;

    public String getTipo() {
        return tipo;
    }

    public void setTipo(String tipo) {
        this.tipo = tipo;
    }

    public int[] getJugada() {
        return jugada;
    }

    public boolean isEsObjetivo() {
        return esObjetivo;
    }

    public int getHeuristica() {
        return heuristica;
    }

    public ArrayList<NodoArbol> getSiguientes() {
        return siguientes;
    }

    public int[][] getTablero() {
        return tablero;
    }

    public int getNivel() {
        return nivel;
    }

    public void setJugada(int[] jugada) {
        this.jugada = jugada;
    }


    public void setSiguientes(ArrayList<NodoArbol> siguientes) {
        this.siguientes = siguientes;
    }

    public void setTablero(int[][] tablero) {
        this.tablero = tablero;
    }

    public void setEsObjetivo(boolean esObjetivo) {
        this.esObjetivo = esObjetivo;
    }

    public void setHeuristica(int heuristica) {
        this.heuristica = heuristica;
    }

    public void setNivel(int nivel) {
        this.nivel = nivel;
    }

    public int compareTo(Object nodo) {


        NodoArbol aux= (NodoArbol) nodo;

        int diferencia=this.heuristica- aux.getHeuristica();

        return diferencia;
    }

    public NodoArbol mejorHijo (){
        NodoArbol mejor=null;
        NodoArbol actual=null;

        for (int i=0; i<this.siguientes.size(); i++)
        {
            actual = siguientes.get(i);

            if (i==0)
                mejor = actual;
            else
            {
                if (actual.getHeuristica() < mejor.getHeuristica())
                    mejor = actual;
            }

        }
        return mejor;
    }
    }

public class Lista{
  private Nodo frente;

     /**
      * Constructor por defecto
      */
     public Lista ()
     {
       frente = null;
     }

     /**
      *  Acceso a la direcci�n del primer Nodo
      *  @return direcci�n del primer Nodo
      */
     public Nodo getFrente()
     {
        return frente;
     }

     /**
      *  Modifica la direcci�n del primer Nodo
      *  @param p nueva direcci�n del primer Nodo
      */
     public void setFrente(Nodo p)
     {
        frente = p;
     }

     /**
      *  Inserta un nodo al principio de la lista
      *  @param x el objeto a almacenar en el nuevo nodo
      */
     public void insertar(Comparable x)
     {
       if (x!=null)
       {
          if(frente!=null && x.getClass()!=frente.getInfo().getClass()) return;

          Nodo p = new Nodo(x, frente);
          frente = p;
       }
     }

    /**
      *  Inserta un nodo al principio de la lista, manteniendo la lista ordenada
      *  @param x el objeto a almacenar en el nuevo nodo
      */
     public void insertarOrdenado(Comparable x)
     {
       if (x!=null)
       {
          if(frente!=null && x.getClass()!=frente.getInfo().getClass()) return;

          Nodo p = frente, q = null;
          //ordena de menor a mayor
          while(p!=null && x.compareTo(p.getInfo()) >= 0)
          {
             q = p;
             p = p.getNext();
          }

          Nodo nuevo = new Nodo(x, p);
          if(q!=null){ q.setNext(nuevo); }
          else { frente = nuevo; }
       }
     }

     public void insertarUltimo(Comparable x){
      if (x==null) return;
      if(frente!=null && x.getClass()!=frente.getInfo().getClass()) return;

      Nodo p=frente;
      Nodo q=null;

      while(p!=null){
        q=p;
        p=p.getNext();
     }

     Nodo nuevo=new Nodo(x,null);
     if(q!=null){
       q.setNext(nuevo);
      }
      else{
      frente=nuevo;
     }

    }

     /**
      *  Elimina el primer nodo
      *  @return una referencia al info del nodo eliminado, o null la lista estaba vac�a
      */
     public Comparable borrar()
     {
       Comparable p = null;
       if(frente != null)
       {
          p = frente.getInfo();
          frente = frente.getNext();
       }
       return p;
     }

     /**
      *  Busca un nodo en la lista que contenga al objeto x
      *  @param x el objeto a buscar
      *  @return una referencia al nodo que contiene a x, si exist�a tal nodo, o null si no exist�a
      */
     public Nodo buscar (Comparable x)
     {
       Nodo p = null;
       if (x!=null)
       {
           if(frente!=null && x.getClass()!=frente.getInfo().getClass()) return p;

           p = frente;
           while(p!=null)
           {
              Comparable y = p.getInfo();
              if(x.compareTo(y)==0)
              {
                 break;
              }
              p = p.getNext();
           }
       }
       return p;
     }

     /**
      *  Elimina el nodo con info = x
      *  @param x el objeto a eliminar
      */
     public void borrar(Comparable x)
     {
        if(x!=null)
        {
           if(frente!=null && x.getClass()!=frente.getInfo().getClass()) return;

           Nodo p = frente, q = null;
           while(p!=null && x.compareTo(p.getInfo())!=0)
           {
              q = p;
              p = p.getNext();
           }

           if(p!=null)
           {
             if(q!=null)
             {
                q.setNext(p.getNext());
             }
             else
             {
                frente = p.getNext();
             }
           }
        }
     }



     public boolean estaVacia(){
      if(this.getFrente()==null){
        return true;
      }
      return false;
     }

     public int getCantidadDeElementos(){
      Nodo p=null;
      int cant=0;

      p=this.getFrente();

      while(p!=null){
       cant++;
       p=p.getNext();
      }

      return cant;

     }

     /**
      *  Redefine el m�todo toString
      *  @return el contenido de la lista convertido a String
      */
     public String toString()
     {
        Nodo p = frente;
        String res = "Contenido: ";
        while(p != null)
        {
           res = res + p.toString();
           p = p.getNext();
        }
        return res;
     }

}

public class Nodo{
  private Comparable info;
    private Nodo next;

    /**
     *  Constructor por defecto.
     */
    public Nodo ( )
    {
    }

    /**
     *  Crea un nodo incializando todos los atributos en base a par�metros
     */
    public Nodo (Comparable x, Nodo p)
    {
      info = x;
      next = p;
    }

    /**
     *  Accede a la direcci�n del sucesor
     *  @return la direcci�n del nodo sucesor
     */
    public Nodo getNext()
    {
      return next;
    }

    /**
     * Cambia la direcci�n del sucesor
     * @param p direcci�n del nuevo sucesor
     */
    public void setNext(Nodo p)
    {
      next = p;
    }

    /**
     *  Accede al valor del info
     *  @return el valor del info
     */
    public Comparable getInfo()
    {
      return info;
    }

    /**
     * Cambia el valor del info
     * @param p nuevo valor del info
     */
    public void setInfo(Comparable p)
    {
      info = p;
    }

    /**
     * Convierte el contenido del nodo en String
     * @return el contenido del nodo convertido en String
     */
    public String toString()
    {
      return info.toString();
    }


}

}